home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / preccx / prccx240.lha / preccx.c < prev    next >
Text File  |  1993-05-27  |  44KB  |  1,808 lines
  1.  
  2. # define TOKEN char
  3. # define VALUE char*
  4.  
  5. # define BEGIN p_begin()
  6.  
  7. # include "cc.h"
  8. # include "preccx.h"
  9. # undef UNSETNAME
  10. # include "preamble.h"
  11.  
  12.  
  13. int p_begin(){
  14.         static int passes; /* no. of times re-entered MAIN */
  15.         int narg;          /* no of command line args */
  16.         int nswitch;       /* count of command line switches */
  17.         int switches;      /* flag - when doing command line switches */
  18.         int dup2();
  19.         
  20.         if(passes++==0){   /* print motto */
  21.                 printf("\n\
  22. /*       PRE-CC %.2f compiler-compiler   \n\
  23.  *         Copyright Peter Breuer 1989   \n\
  24.  *     <ptb@uk.ac.cam.eng> Tel 0223 68682\n\
  25.  */\n\
  26. ",__PRECC__);
  27.             call_mode=1;/* set no-auto shift in value stack */
  28.             dup2(0,5);  /* save stdin and stdout */
  29.             dup2(1,6);
  30.             nswitch=0;  /* begin command line processing */
  31.             switches=1;
  32.             for (narg=1;narg<p_argc;narg++){
  33.                 switch(p_argv[narg][0]){
  34.                 case '-':
  35.                     if(!switches) /* mixed switches and files */
  36.                       usage (1);
  37.                     nswitch++;
  38.                     switch(p_argv[narg][1]){
  39.                     case 'r': /* read buffer size in Kb */
  40.                         getkintarg(p_argv[narg]+2,&precc_data.readbuffersize,
  41.                                    sizeof (TOKEN) + sizeof (VALUE));
  42.                         break;
  43.                     case 'p': /* internal program length in Kb */
  44.                         getkintarg(p_argv[narg]+2,&precc_data.maxprogramsize,
  45.                                    sizeof (VALUE));
  46.                         break;
  47.                     case 'v': /* internal VALUE stack size in Kb */
  48.                         getkintarg(p_argv[narg]+2,&precc_data.stacksize,
  49.                                    sizeof (STACKVALUE));
  50.                         break;
  51.                     case 'f': /* internal FRAME stack size in Kb */
  52.                         getkintarg(p_argv[narg]+2,&precc_data.contextstacksize,
  53.                                    sizeof (FRAME));
  54.                         break;
  55.                     default: /* unknown option */
  56.                         usage(3);
  57.                     }
  58.                     break;
  59.                 default:
  60.                     switches=0; /* end of switches */
  61.                     break;
  62.                 }
  63.             }                   /* now deal with redirects */
  64.             switch(p_argc-1-nswitch){
  65.             case 2:
  66.                     if (freopen(p_argv[nswitch+2], "w", stdout)==NULL) 
  67.                       usage (2);
  68.             case 1:
  69.                     if (freopen(p_argv[nswitch+1], "r", stdin)==NULL) 
  70.                       usage (5);
  71.             case 0: break;
  72.             default: /* too many files named */
  73.                     usage (6);
  74.             }
  75.         }
  76.         return 0;                /* success */
  77. }
  78.  
  79. char *envs[20];    /*environment stack*/
  80. char *plvs[20];    /*plainenv    stack*/
  81. int  ecount=0;     /*pointer */
  82.  
  83. #define environment envs[ecount] /* holds the typed list of params */
  84. #define plainenv plvs[ecount]    /* this holds the untyped list of params */
  85.  
  86. void pushenv()
  87. /* save the current environment and begin another */
  88. {
  89.     ecount++;
  90. }
  91.  
  92. void popenv()
  93. /* release the current env and recall the old */
  94. {
  95.     ecount--;
  96. }
  97.  
  98.  
  99.  
  100.                 /* -- idens with params ------- */
  101.  
  102. static VOID hid0(){
  103. VV(2)=V(1);
  104. }
  105. static STATUS hid1(){
  106. PARSER rdbrktargs;ACTION hid0;
  107. return(p_attach0n(TOPARSER rdbrktargs,0,hid0,0));
  108. }
  109. static STATUS hid2(){
  110. PARSER hid1, p_nothing0;
  111. return(p_andparse0n(TOPARSER hid1,0,TOPARSER p_nothing0,0));
  112. }
  113. static STATUS hid3(){
  114. PARSER hid2;
  115. return(p_option0n(TOPARSER hid2,0));
  116. }
  117. static STATUS hid4(){
  118. PARSER IDENTIFIER, hid3;
  119. return(p_andparse0n(TOPARSER IDENTIFIER,0,TOPARSER hid3,0));
  120. }
  121. STATUS nameplusargs(){
  122. PARSER hid4;
  123. return((TOPARSER hid4)());
  124. }
  125.  
  126. static VOID hid5(){
  127. VV(2)=V(1);
  128. }
  129. static STATUS hid6(){
  130. PARSER rdbrktvars;ACTION hid5;
  131. return(p_attach0n(TOPARSER rdbrktvars,0,hid5,0));
  132. }
  133. static STATUS hid7(){
  134. PARSER hid6, p_nothing0;
  135. return(p_andparse0n(TOPARSER hid6,0,TOPARSER p_nothing0,0));
  136. }
  137. static STATUS hid8(){
  138. PARSER hid7;
  139. return(p_option0n(TOPARSER hid7,0));
  140. }
  141. static STATUS hid9(){
  142. PARSER IDENTIFIER, hid8;
  143. return(p_andparse0n(TOPARSER IDENTIFIER,0,TOPARSER hid8,0));
  144. }
  145. STATUS nameplusvars(){
  146. PARSER hid9;
  147. return((TOPARSER hid9)());
  148. }
  149.  
  150. static STATUS hid10(){
  151. PARSER WHITESPACE, closebracket;
  152. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER closebracket,0));
  153. }
  154. static STATUS hid11(){
  155. PARSER someargs, hid10;
  156. return(p_andparse0n(TOPARSER someargs,0,TOPARSER hid10,0));
  157. }
  158. static STATUS hid12(){
  159. PARSER WHITESPACE, hid11;
  160. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid11,0));
  161. }
  162. static STATUS hid13(){
  163. PARSER openbracket, hid12;
  164. return(p_andparse0n(TOPARSER openbracket,0,TOPARSER hid12,0));
  165. }
  166. static VOID hid14(){
  167. VV(5)=V(3);
  168. }
  169. static STATUS hid15(){
  170. PARSER hid13;ACTION hid14;
  171. return(p_attach0n(TOPARSER hid13,0,hid14,0));
  172. }
  173. static STATUS hid16(){
  174. PARSER hid15, p_nothing0;
  175. return(p_andparse0n(TOPARSER hid15,0,TOPARSER p_nothing0,0));
  176. }
  177. STATUS sqbrktargs(){
  178. PARSER hid16;
  179. return((TOPARSER hid16)());
  180. }
  181.  
  182. static STATUS hid17(){
  183. PARSER WHITESPACE, closeparen;
  184. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER closeparen,0));
  185. }
  186. static STATUS hid18(){
  187. PARSER theargs, hid17;
  188. return(p_andparse0n(TOPARSER theargs,0,TOPARSER hid17,0));
  189. }
  190. static STATUS hid19(){
  191. PARSER WHITESPACE, hid18;
  192. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid18,0));
  193. }
  194. static STATUS hid20(){
  195. PARSER openparen, hid19;
  196. return(p_andparse0n(TOPARSER openparen,0,TOPARSER hid19,0));
  197. }
  198. static VOID hid21(){
  199. VV(5)=V(3);
  200. }
  201. static STATUS hid22(){
  202. PARSER hid20;ACTION hid21;
  203. return(p_attach0n(TOPARSER hid20,0,hid21,0));
  204. }
  205. static STATUS hid23(){
  206. PARSER hid22, p_nothing0;
  207. return(p_andparse0n(TOPARSER hid22,0,TOPARSER p_nothing0,0));
  208. }
  209. STATUS rdbrktargs(){
  210. PARSER hid23;
  211. return((TOPARSER hid23)());
  212. }
  213.  
  214. static STATUS hid24(){
  215. PARSER WHITESPACE, closeparen;
  216. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER closeparen,0));
  217. }
  218. static STATUS hid25(){
  219. PARSER thevars, hid24;
  220. return(p_andparse0n(TOPARSER thevars,0,TOPARSER hid24,0));
  221. }
  222. static STATUS hid26(){
  223. PARSER WHITESPACE, hid25;
  224. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid25,0));
  225. }
  226. static STATUS hid27(){
  227. PARSER openparen, hid26;
  228. return(p_andparse0n(TOPARSER openparen,0,TOPARSER hid26,0));
  229. }
  230. static VOID hid28(){
  231. VV(5)=V(3);
  232. }
  233. static STATUS hid29(){
  234. PARSER hid27;ACTION hid28;
  235. return(p_attach0n(TOPARSER hid27,0,hid28,0));
  236. }
  237. static STATUS hid30(){
  238. PARSER hid29, p_nothing0;
  239. return(p_andparse0n(TOPARSER hid29,0,TOPARSER p_nothing0,0));
  240. }
  241. STATUS rdbrktvars(){
  242. PARSER hid30;
  243. return((TOPARSER hid30)());
  244. }
  245.  
  246. /* these are token-driven writes */
  247.  
  248. static VOID hid31(){
  249.  VV(1) = putchar(T(1)); 
  250. }
  251. static STATUS hid32(){
  252. PARSER OPENPAREN;ACTION hid31;
  253. return(p_attach0n(TOPARSER OPENPAREN,0,hid31,0));
  254. }
  255. static STATUS hid33(){
  256. PARSER hid32, p_nothing0;
  257. return(p_andparse0n(TOPARSER hid32,0,TOPARSER p_nothing0,0));
  258. }
  259. STATUS openparen(){
  260. PARSER hid33;
  261. return((TOPARSER hid33)());
  262. }
  263.  
  264. static VOID hid34(){
  265.  VV(1) = putchar(T(1)); 
  266. }
  267. static STATUS hid35(){
  268. PARSER CLOSEPAREN;ACTION hid34;
  269. return(p_attach0n(TOPARSER CLOSEPAREN,0,hid34,0));
  270. }
  271. static STATUS hid36(){
  272. PARSER hid35, p_nothing0;
  273. return(p_andparse0n(TOPARSER hid35,0,TOPARSER p_nothing0,0));
  274. }
  275. STATUS closeparen(){
  276. PARSER hid36;
  277. return((TOPARSER hid36)());
  278. }
  279.  
  280. static VOID hid37(){
  281.  VV(1) = putchar(T(1)); 
  282. }
  283. static STATUS hid38(){
  284. PARSER OPENBRACKET;ACTION hid37;
  285. return(p_attach0n(TOPARSER OPENBRACKET,0,hid37,0));
  286. }
  287. static STATUS hid39(){
  288. PARSER hid38, p_nothing0;
  289. return(p_andparse0n(TOPARSER hid38,0,TOPARSER p_nothing0,0));
  290. }
  291. STATUS openbracket(){
  292. PARSER hid39;
  293. return((TOPARSER hid39)());
  294. }
  295.  
  296. static VOID hid40(){
  297.  VV(1) = putchar(T(1)); 
  298. }
  299. static STATUS hid41(){
  300. PARSER CLOSEBRACKET;ACTION hid40;
  301. return(p_attach0n(TOPARSER CLOSEBRACKET,0,hid40,0));
  302. }
  303. static STATUS hid42(){
  304. PARSER hid41, p_nothing0;
  305. return(p_andparse0n(TOPARSER hid41,0,TOPARSER p_nothing0,0));
  306. }
  307. STATUS closebracket(){
  308. PARSER hid42;
  309. return((TOPARSER hid42)());
  310. }
  311.  
  312.  
  313.  
  314. static VOID hid43(){
  315.  VV(0)=""; 
  316. }
  317. static STATUS hid44(){
  318. PARSER p_nothing0;ACTION hid43;
  319. return(p_attach0n(TOPARSER p_nothing0,0,hid43,0));
  320. }
  321. static STATUS hid45(){
  322. PARSER hid44, p_nothing0;
  323. return(p_andparse0n(TOPARSER hid44,0,TOPARSER p_nothing0,0));
  324. }
  325. static STATUS hid46(){
  326. PARSER someargs, hid45;
  327. return(p_orparse0n(TOPARSER someargs,0,TOPARSER hid45,0));
  328. }
  329. STATUS theargs(){
  330. PARSER hid46;
  331. return((TOPARSER hid46)());
  332. }
  333.  
  334. static VOID hid47(){
  335.  VV(0)=""; 
  336. }
  337. static STATUS hid48(){
  338. PARSER p_nothing0;ACTION hid47;
  339. return(p_attach0n(TOPARSER p_nothing0,0,hid47,0));
  340. }
  341. static STATUS hid49(){
  342. PARSER hid48, p_nothing0;
  343. return(p_andparse0n(TOPARSER hid48,0,TOPARSER p_nothing0,0));
  344. }
  345. static STATUS hid50(){
  346. PARSER somevars, hid49;
  347. return(p_orparse0n(TOPARSER somevars,0,TOPARSER hid49,0));
  348. }
  349. STATUS thevars(){
  350. PARSER hid50;
  351. return((TOPARSER hid50)());
  352. }
  353.  
  354. static VOID hid51(){
  355.  VV(1)=putchar(','); 
  356. }
  357. static STATUS hid52(){
  358. PARSER COMMA;ACTION hid51;
  359. return(p_attach0n(TOPARSER COMMA,0,hid51,0));
  360. }
  361. static STATUS hid53(){
  362. PARSER hid52, p_nothing0;
  363. return(p_andparse0n(TOPARSER hid52,0,TOPARSER p_nothing0,0));
  364. }
  365. STATUS comma(){
  366. PARSER hid53;
  367. return((TOPARSER hid53)());
  368. }
  369.  
  370. static STATUS hid54(){
  371. PARSER WHITESPACE, expr;
  372. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER expr,0));
  373. }
  374. static STATUS hid55(){
  375. PARSER comma, hid54;
  376. return(p_andparse0n(TOPARSER comma,0,TOPARSER hid54,0));
  377. }
  378. static STATUS hid56(){
  379. PARSER WHITESPACE, hid55;
  380. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid55,0));
  381. }
  382. static VOID hid57(){
  383. VV(5)=V(1);
  384. }
  385. static STATUS hid58(){
  386. PARSER hid56;ACTION hid57;
  387. return(p_attach0n(TOPARSER hid56,0,hid57,0));
  388. }
  389. static STATUS hid59(){
  390. PARSER hid58, p_nothing0;
  391. return(p_andparse0n(TOPARSER hid58,0,TOPARSER p_nothing0,0));
  392. }
  393. static STATUS hid60(){
  394. PARSER hid59;
  395. return(p_many0n(TOPARSER hid59,0));
  396. }
  397. static STATUS hid61(){
  398. PARSER expr, hid60;
  399. return(p_andparse0n(TOPARSER expr,0,TOPARSER hid60,0));
  400. }
  401. STATUS someargs(){
  402. PARSER hid61;
  403. return((TOPARSER hid61)());
  404. }
  405.  
  406.  
  407. static STATUS hid62(){
  408. PARSER WHITESPACE, var;
  409. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER var,0));
  410. }
  411. static STATUS hid63(){
  412. PARSER comma, hid62;
  413. return(p_andparse0n(TOPARSER comma,0,TOPARSER hid62,0));
  414. }
  415. static STATUS hid64(){
  416. PARSER WHITESPACE, hid63;
  417. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid63,0));
  418. }
  419. static VOID hid65(){
  420. VV(5)=V(1);
  421. }
  422. static STATUS hid66(){
  423. PARSER hid64;ACTION hid65;
  424. return(p_attach0n(TOPARSER hid64,0,hid65,0));
  425. }
  426. static STATUS hid67(){
  427. PARSER hid66, p_nothing0;
  428. return(p_andparse0n(TOPARSER hid66,0,TOPARSER p_nothing0,0));
  429. }
  430. static STATUS hid68(){
  431. PARSER hid67;
  432. return(p_many0n(TOPARSER hid67,0));
  433. }
  434. static STATUS hid69(){
  435. PARSER var, hid68;
  436. return(p_andparse0n(TOPARSER var,0,TOPARSER hid68,0));
  437. }
  438. STATUS somevars(){
  439. PARSER hid69;
  440. return((TOPARSER hid69)());
  441. }
  442.  
  443.  
  444. static VOID hid70(){
  445. if(*putargs(""))putargs(",");putargs("PARAM ");putargs(V(1));                 if(*putmeta(""))putmeta(",");putmeta(V(1));
  446. }
  447. static STATUS hid71(){
  448. PARSER IDENTIFIER;ACTION hid70;
  449. return(p_attach0n(TOPARSER IDENTIFIER,0,hid70,0));
  450. }
  451. static STATUS hid72(){
  452. PARSER hid71, p_nothing0;
  453. return(p_andparse0n(TOPARSER hid71,0,TOPARSER p_nothing0,0));
  454. }
  455. STATUS var(){
  456. PARSER hid72;
  457. return((TOPARSER hid72)());
  458. }
  459.  
  460.  
  461.                 /* -- parser identifiers --- */
  462.  
  463. /* collect IDENTIFIERs from buffers */
  464.  
  465. void SETENV()
  466. /* seal the current environment to be whats in the buffers now */
  467. {
  468.   environment=putargs("");
  469.   plainenv=putmeta("");
  470.   getargs(&environment);
  471.   getmeta(&plainenv);
  472. }
  473.  
  474. static VOID hid73(){
  475. getname(&V(1)); SETENV();
  476. }
  477. static STATUS hid74(){
  478. PARSER nameplusvars;ACTION hid73;
  479. return(p_attach0n(TOPARSER nameplusvars,0,hid73,0));
  480. }
  481. static STATUS hid75(){
  482. PARSER hid74, p_nothing0;
  483. return(p_andparse0n(TOPARSER hid74,0,TOPARSER p_nothing0,0));
  484. }
  485. STATUS declname(){
  486. PARSER hid75;
  487. return((TOPARSER hid75)());
  488. }
  489.  
  490. /*@ [ BACKSLASH IDENTIFIER :VV(3)=V(3);getname(&V(3));ADDVAR(V(3));: ]
  491.  */
  492.  
  493. /* collect a domain IDENTIFIER in the same way */
  494.  
  495. static VOID hid76(){
  496. getname(&V(1));
  497. }
  498. static STATUS hid77(){
  499. PARSER nameplusargs;ACTION hid76;
  500. return(p_attach0n(TOPARSER nameplusargs,0,hid76,0));
  501. }
  502. static STATUS hid78(){
  503. PARSER hid77, p_nothing0;
  504. return(p_andparse0n(TOPARSER hid77,0,TOPARSER p_nothing0,0));
  505. }
  506. STATUS exprname(){
  507. PARSER hid78;
  508. return((TOPARSER hid78)());
  509. }
  510.  
  511.  
  512.                 /* -- start of precc defn ----   */
  513.  
  514. /* In 2.40 and above ...
  515.  @ declaration = ^ AT !{declerr} WHITESPACE declname
  516.  @               WHITESPACE EQUALS WHITESPACE
  517.  @               expression WHITESPACE
  518.  @               :VV(10) = P_REN(V(5),V(9));RESET;:
  519. */
  520.  
  521. /* In 2.31 and below ...
  522. */
  523.  
  524. static STATUS hid79(){
  525. PARSER expression, WHITESPACE;
  526. return(p_andparse0n(TOPARSER expression,0,TOPARSER WHITESPACE,0));
  527. }
  528. static STATUS hid80(){
  529. PARSER WHITESPACE, hid79;
  530. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid79,0));
  531. }
  532. static STATUS hid81(){
  533. PARSER EQUALS, hid80;
  534. return(p_andparse0n(TOPARSER EQUALS,0,TOPARSER hid80,0));
  535. }
  536. static STATUS hid82(){
  537. PARSER WHITESPACE, hid81;
  538. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid81,0));
  539. }
  540. static STATUS hid83(){
  541. PARSER declname, hid82;
  542. return(p_andparse0n(TOPARSER declname,0,TOPARSER hid82,0));
  543. }
  544. static STATUS hid84(){
  545. PARSER WHITESPACE, hid83;
  546. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid83,0));
  547. }
  548. static STATUS hid85(){
  549. PARSER p_uniq0, hid84;
  550. return(p_andparse0n(TOPARSER p_uniq0,0,TOPARSER hid84,0));
  551. }
  552. static VOID hid86(){
  553. VV(10) = P_REN(V(5),V(9));RESET;
  554. }
  555. static STATUS hid87(){
  556. PARSER hid85;ACTION hid86;
  557. return(p_attach0n(TOPARSER hid85,0,hid86,0));
  558. }
  559. static STATUS hid88(){
  560. PARSER hid87, p_nothing0;
  561. return(p_andparse0n(TOPARSER hid87,0,TOPARSER p_nothing0,0));
  562. }
  563. static VOID hid89(){
  564.  VV(2) = V(1);RESET;
  565. }
  566. static STATUS hid90(){
  567. PARSER declerr;ACTION hid89;
  568. return(p_attach0n(TOPARSER declerr,0,hid89,0));
  569. }
  570. static STATUS hid91(){
  571. PARSER hid90, p_nothing0;
  572. return(p_andparse0n(TOPARSER hid90,0,TOPARSER p_nothing0,0));
  573. }
  574. static STATUS hid92(){
  575. PARSER hid88, hid91;
  576. return(p_orparse0n(TOPARSER hid88,0,TOPARSER hid91,0));
  577. }
  578. static STATUS hid93(){
  579. PARSER AT, hid92;
  580. return(p_andparse0n(TOPARSER AT,0,TOPARSER hid92,0));
  581. }
  582. static STATUS hid94(){
  583. PARSER p_first0, hid93;
  584. return(p_andparse0n(TOPARSER p_first0,0,TOPARSER hid93,0));
  585. }
  586. STATUS declaration(){
  587. PARSER hid94;
  588. return((TOPARSER hid94)());
  589. }
  590.  
  591. static STATUS hid95(){
  592. PARSER printdeclerr, passthrough;
  593. return(p_andparse0n(TOPARSER printdeclerr,0,TOPARSER passthrough,0));
  594. }
  595. static VOID hid96(){
  596. VV(2)=V(1);
  597. }
  598. static STATUS hid97(){
  599. PARSER hid95;ACTION hid96;
  600. return(p_attach0n(TOPARSER hid95,0,hid96,0));
  601. }
  602. static STATUS hid98(){
  603. PARSER hid97, p_nothing0;
  604. return(p_andparse0n(TOPARSER hid97,0,TOPARSER p_nothing0,0));
  605. }
  606. STATUS declerr(){
  607. PARSER hid98;
  608. return((TOPARSER hid98)());
  609. }
  610.  
  611. static VOID hid99(){
  612. VV(0)="@";                 printf("line %d error: malformed declaration\n@?",yylineno);
  613. }
  614. static STATUS hid100(){
  615. PARSER p_nothing0;ACTION hid99;
  616. return(p_attach0n(TOPARSER p_nothing0,0,hid99,0));
  617. }
  618. static STATUS hid101(){
  619. PARSER hid100, p_nothing0;
  620. return(p_andparse0n(TOPARSER hid100,0,TOPARSER p_nothing0,0));
  621. }
  622. STATUS printdeclerr(){
  623. PARSER hid101;
  624. return((TOPARSER hid101)());
  625. }
  626.  
  627.                 /* that was it. Now the top level (MAIN) parse. */
  628.  
  629. static STATUS hid102(){
  630. PARSER notanat, passthrough;
  631. return(p_andparse0n(TOPARSER notanat,0,TOPARSER passthrough,0));
  632. }
  633. static VOID hid103(){
  634. VV(0)="";printf("\n");
  635. }
  636. static STATUS hid104(){
  637. PARSER p_nothing0;ACTION hid103;
  638. return(p_attach0n(TOPARSER p_nothing0,0,hid103,0));
  639. }
  640. static STATUS hid105(){
  641. PARSER hid104, p_nothing0;
  642. return(p_andparse0n(TOPARSER hid104,0,TOPARSER p_nothing0,0));
  643. }
  644. static STATUS hid106(){
  645. PARSER hid102, hid105;
  646. return(p_orparse0n(TOPARSER hid102,0,TOPARSER hid105,0));
  647. }
  648. static STATUS hid107(){
  649. PARSER declaration, hid106;
  650. return(p_orparse0n(TOPARSER declaration,0,TOPARSER hid106,0));
  651. }
  652. STATUS line(){
  653. PARSER hid107;
  654. return((TOPARSER hid107)());
  655. }
  656.  
  657. static VOID hid108(){
  658.  VV(1)=putchar(T(1)); 
  659. }
  660. static STATUS hid109(){
  661. PARSER NOTANAT;ACTION hid108;
  662. return(p_attach0n(TOPARSER NOTANAT,0,hid108,0));
  663. }
  664. static STATUS hid110(){
  665. PARSER hid109, p_nothing0;
  666. return(p_andparse0n(TOPARSER hid109,0,TOPARSER p_nothing0,0));
  667. }
  668. STATUS notanat(){
  669. PARSER hid110;
  670. return((TOPARSER hid110)());
  671. }
  672.  
  673. /* this is a deliberate pop of the value 'behind'  if we get none */
  674.  
  675. static VOID hid111(){
  676.  VV(2)=V(1); 
  677. }
  678. static STATUS hid112(){
  679. PARSER anychar;ACTION hid111;
  680. return(p_attach0n(TOPARSER anychar,0,hid111,0));
  681. }
  682. static STATUS hid113(){
  683. PARSER hid112, p_nothing0;
  684. return(p_andparse0n(TOPARSER hid112,0,TOPARSER p_nothing0,0));
  685. }
  686. static STATUS hid114(){
  687. PARSER hid113;
  688. return(p_many0n(TOPARSER hid113,0));
  689. }
  690. static VOID hid115(){
  691. getname(&V(1));printf("%s\n",V(1)); RESET;
  692. }
  693. static STATUS hid116(){
  694. PARSER hid114;ACTION hid115;
  695. return(p_attach0n(TOPARSER hid114,0,hid115,0));
  696. }
  697. static STATUS hid117(){
  698. PARSER hid116, p_nothing0;
  699. return(p_andparse0n(TOPARSER hid116,0,TOPARSER p_nothing0,0));
  700. }
  701. STATUS passthrough(){
  702. PARSER hid117;
  703. return((TOPARSER hid117)());
  704. }
  705.  
  706. static VOID hid118(){
  707.  VV(1)=putchar(T(1)); 
  708. }
  709. static STATUS hid119(){
  710. PARSER ANYTHING;ACTION hid118;
  711. return(p_attach0n(TOPARSER ANYTHING,0,hid118,0));
  712. }
  713. static STATUS hid120(){
  714. PARSER hid119, p_nothing0;
  715. return(p_andparse0n(TOPARSER hid119,0,TOPARSER p_nothing0,0));
  716. }
  717. STATUS anychar(){
  718. PARSER hid120;
  719. return((TOPARSER hid120)());
  720. }
  721.  
  722.                 /* ----  parser expressions -------- */
  723.  
  724. static STATUS hid121(){
  725. PARSER alternates, empty;
  726. return(p_orparse0n(TOPARSER alternates,0,TOPARSER empty,0));
  727. }
  728. STATUS expression(){
  729. PARSER hid121;
  730. return((TOPARSER hid121)());
  731. }
  732.  
  733. /* a <'|'> separated series, at least one <'|'>  - note the overpull 
  734.    I prefer the order which results from recursion */
  735.  
  736. static STATUS hid122(){
  737. PARSER WHITESPACE, alternates;
  738. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER alternates,0));
  739. }
  740. static STATUS hid123(){
  741. PARSER OR, hid122;
  742. return(p_andparse0n(TOPARSER OR,0,TOPARSER hid122,0));
  743. }
  744. static STATUS hid124(){
  745. PARSER WHITESPACE, hid123;
  746. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid123,0));
  747. }
  748. static VOID hid125(){
  749. char *n;                 VV(5)=(GETNEWNAME(&n,plainenv,NULL),P_ALT(n,V(1),V(5)));
  750. }
  751. static STATUS hid126(){
  752. PARSER hid124;ACTION hid125;
  753. return(p_attach0n(TOPARSER hid124,0,hid125,0));
  754. }
  755. static STATUS hid127(){
  756. PARSER hid126, p_nothing0;
  757. return(p_andparse0n(TOPARSER hid126,0,TOPARSER p_nothing0,0));
  758. }
  759. static STATUS hid128(){
  760. PARSER hid127;
  761. return(p_option0n(TOPARSER hid127,0));
  762. }
  763. static STATUS hid129(){
  764. PARSER sequence, hid128;
  765. return(p_andparse0n(TOPARSER sequence,0,TOPARSER hid128,0));
  766. }
  767. STATUS alternates(){
  768. PARSER hid129;
  769. return((TOPARSER hid129)());
  770. }
  771.  
  772. /* appending is much more efficient than prepending because I don't waste
  773.   C-stack space with MARK before a parse */
  774.  
  775. static STATUS hid130(){
  776. PARSER WHITESPACE, manysequents;
  777. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER manysequents,0));
  778. }
  779. static STATUS hid131(){
  780. PARSER command, hid130;
  781. return(p_andparse0n(TOPARSER command,0,TOPARSER hid130,0));
  782. }
  783. static STATUS hid132(){
  784. PARSER WHITESPACE, hid131;
  785. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid131,0));
  786. }
  787. static VOID hid133(){
  788. char *n;                  VV(3)=(GETNEWNAME(&n,plainenv,NULL),P_AND(n,V(1),V(3)));
  789. }
  790. static STATUS hid134(){
  791. PARSER hid132;ACTION hid133;
  792. return(p_attach0n(TOPARSER hid132,0,hid133,0));
  793. }
  794. static STATUS hid135(){
  795. PARSER hid134, p_nothing0;
  796. return(p_andparse0n(TOPARSER hid134,0,TOPARSER p_nothing0,0));
  797. }
  798. static STATUS hid136(){
  799. PARSER hid135;
  800. return(p_many0n(TOPARSER hid135,0));
  801. }
  802. static STATUS hid137(){
  803. PARSER manysequents, hid136;
  804. return(p_andparse0n(TOPARSER manysequents,0,TOPARSER hid136,0));
  805. }
  806. STATUS sequence(){
  807. PARSER hid137;
  808. return((TOPARSER hid137)());
  809. }
  810.  
  811.  /* here we attach to the manysequents which this follows */
  812.  
  813. static STATUS hid138(){
  814. PARSER c_code, COLONorEOL;
  815. return(p_andparse0n(TOPARSER c_code,0,TOPARSER COLONorEOL,0));
  816. }
  817. static STATUS hid139(){
  818. PARSER COLON, hid138;
  819. return(p_andparse0n(TOPARSER COLON,0,TOPARSER hid138,0));
  820. }
  821. static VOID hid140(){
  822.  char *n,*m;             VV(5)=(GETNEWNAME(&n,plainenv,NULL),GETNEWNAME(&m,plainenv,NULL),P_ATT(m,V(1),n,V(4))); 
  823. }
  824. static STATUS hid141(){
  825. PARSER hid139;ACTION hid140;
  826. return(p_attach0n(TOPARSER hid139,0,hid140,0));
  827. }
  828. static STATUS hid142(){
  829. PARSER hid141, p_nothing0;
  830. return(p_andparse0n(TOPARSER hid141,0,TOPARSER p_nothing0,0));
  831. }
  832. STATUS command(){
  833. PARSER hid142;
  834. return((TOPARSER hid142)());
  835. }
  836.  
  837. /* commands can't be treated as ordinary atoms at the moment, because they
  838.  * are required to end a sequence of 'and's and force a stack shift */
  839.  
  840. static VOID hid143(){
  841.  VV(1)=V(1); getname(&V(1)); 
  842. }
  843. static STATUS hid144(){
  844. PARSER cstuffs;ACTION hid143;
  845. return(p_attach0n(TOPARSER cstuffs,0,hid143,0));
  846. }
  847. static STATUS hid145(){
  848. PARSER hid144, p_nothing0;
  849. return(p_andparse0n(TOPARSER hid144,0,TOPARSER p_nothing0,0));
  850. }
  851. STATUS c_code(){
  852. PARSER hid145;
  853. return((TOPARSER hid145)());
  854. }
  855.  
  856. /* the stuff inside a command is a sequence of C constants or C tokens */
  857.  
  858. static VOID hid146(){
  859.  VV(2) = V(1); 
  860. }
  861. static STATUS hid147(){
  862. PARSER cstuff;ACTION hid146;
  863. return(p_attach0n(TOPARSER cstuff,0,hid146,0));
  864. }
  865. static STATUS hid148(){
  866. PARSER hid147, p_nothing0;
  867. return(p_andparse0n(TOPARSER hid147,0,TOPARSER p_nothing0,0));
  868. }
  869. static STATUS hid149(){
  870. PARSER hid148;
  871. return(p_many0n(TOPARSER hid148,0));
  872. }
  873. static STATUS hid150(){
  874. PARSER cstuff, hid149;
  875. return(p_andparse0n(TOPARSER cstuff,0,TOPARSER hid149,0));
  876. }
  877. static VOID hid151(){
  878.  VV(0) =""; 
  879. }
  880. static STATUS hid152(){
  881. PARSER p_nothing0;ACTION hid151;
  882. return(p_attach0n(TOPARSER p_nothing0,0,hid151,0));
  883. }
  884. static STATUS hid153(){
  885. PARSER hid152, p_nothing0;
  886. return(p_andparse0n(TOPARSER hid152,0,TOPARSER p_nothing0,0));
  887. }
  888. static STATUS hid154(){
  889. PARSER hid150, hid153;
  890. return(p_orparse0n(TOPARSER hid150,0,TOPARSER hid153,0));
  891. }
  892. STATUS cstuffs(){
  893. PARSER hid154;
  894. return((TOPARSER hid154)());
  895. }
  896.  
  897. /* all the component tokens are accumulating in the cbuff */
  898.  
  899. static VOID hid155(){
  900.  VV(1) = putchar(T(1)); 
  901. }
  902. static STATUS hid156(){
  903. PARSER NOTACOLON;ACTION hid155;
  904. return(p_attach0n(TOPARSER NOTACOLON,0,hid155,0));
  905. }
  906. static STATUS hid157(){
  907. PARSER hid156, p_nothing0;
  908. return(p_andparse0n(TOPARSER hid156,0,TOPARSER p_nothing0,0));
  909. }
  910. static STATUS hid158(){
  911. PARSER COMMENT, hid157;
  912. return(p_orparse0n(TOPARSER COMMENT,0,TOPARSER hid157,0));
  913. }
  914. static STATUS hid159(){
  915. PARSER DOLLARID, hid158;
  916. return(p_orparse0n(TOPARSER DOLLARID,0,TOPARSER hid158,0));
  917. }
  918. static STATUS hid160(){
  919. PARSER CHARCONST, hid159;
  920. return(p_orparse0n(TOPARSER CHARCONST,0,TOPARSER hid159,0));
  921. }
  922. static STATUS hid161(){
  923. PARSER STRING, hid160;
  924. return(p_orparse0n(TOPARSER STRING,0,TOPARSER hid160,0));
  925. }
  926. STATUS cstuff(){
  927. PARSER hid161;
  928. return((TOPARSER hid161)());
  929. }
  930.  
  931. static STATUS hid162(){
  932. PARSER sequent, empty;
  933. return(p_orparse0n(TOPARSER sequent,0,TOPARSER empty,0));
  934. }
  935. static STATUS hid163(){
  936. PARSER moresequents;
  937. return(p_option0n(TOPARSER moresequents,0));
  938. }
  939. static STATUS hid164(){
  940. PARSER hid162, hid163;
  941. return(p_andparse0n(TOPARSER hid162,0,TOPARSER hid163,0));
  942. }
  943. STATUS manysequents(){
  944. PARSER hid164;
  945. return((TOPARSER hid164)());
  946. }
  947.  
  948.         /* overpull again in the option 
  949.            again, I prefer to use recursion for better output order */
  950.  
  951.  
  952. void ADDVAR(char *x)
  953. /* make a new environment with one more var. save the old. */
  954. {
  955.   char *n;
  956.                  /* finish off current env */
  957.   getargs(&n);
  958.   getmeta(&n);
  959.                  /* copy old to new - start by buffering it */
  960.   putargs(environment);
  961.   putmeta(plainenv);
  962.                  /* increment env count */
  963.   pushenv();
  964.                  /* point env at buffer */
  965.   environment=putargs("");
  966.   plainenv=putmeta("");
  967.                  /* add new var */
  968.   if(*environment){
  969.     putargs(",");
  970.     putmeta(",");
  971.   }
  972.   putargs("PARAM ");
  973.   putargs(x);
  974.   putmeta(x);
  975.                  /* note that the buffer is still unterminated */
  976. }
  977.  
  978. /* without a parameterized spec, I can't prevent repetitions */
  979.  
  980. static STATUS hid165(){
  981. PARSER BACKSLASH, IDENTIFIER;
  982. return(p_andparse0n(TOPARSER BACKSLASH,0,TOPARSER IDENTIFIER,0));
  983. }
  984. static VOID hid166(){
  985. VV(2)=V(2);getname(&V(2));ADDVAR(V(2));
  986. }
  987. static STATUS hid167(){
  988. PARSER hid165;ACTION hid166;
  989. return(p_attach0n(TOPARSER hid165,0,hid166,0));
  990. }
  991. static STATUS hid168(){
  992. PARSER hid167, p_nothing0;
  993. return(p_andparse0n(TOPARSER hid167,0,TOPARSER p_nothing0,0));
  994. }
  995. STATUS newvar(){
  996. PARSER hid168;
  997. return((TOPARSER hid168)());
  998. }
  999.  
  1000. /* these next two are a pair. take the shifts together */
  1001.  
  1002. static STATUS hid169(){
  1003. PARSER moresequents;
  1004. return(p_option0n(TOPARSER moresequents,0));
  1005. }
  1006. static STATUS hid170(){
  1007. PARSER sequent, hid169;
  1008. return(p_andparse0n(TOPARSER sequent,0,TOPARSER hid169,0));
  1009. }
  1010. STATUS somesequents(){
  1011. PARSER hid170;
  1012. return((TOPARSER hid170)());
  1013. }
  1014.  
  1015. static STATUS hid171(){
  1016. PARSER SOMESPACE, manysequents;
  1017. return(p_andparse0n(TOPARSER SOMESPACE,0,TOPARSER manysequents,0));
  1018. }
  1019. static STATUS hid172(){
  1020. PARSER newvar, hid171;
  1021. return(p_andparse0n(TOPARSER newvar,0,TOPARSER hid171,0));
  1022. }
  1023. static VOID hid173(){
  1024.  char *n; VV(4)=V(1);popenv();          GETNEWNAME(&n,plainenv,NULL);V(1)=P_STAR(n,V(1),V(4),V(2));
  1025. }
  1026. static STATUS hid174(){
  1027. PARSER hid172;ACTION hid173;
  1028. return(p_attach0n(TOPARSER hid172,0,hid173,0));
  1029. }
  1030. static STATUS hid175(){
  1031. PARSER hid174, p_nothing0;
  1032. return(p_andparse0n(TOPARSER hid174,0,TOPARSER p_nothing0,0));
  1033. }
  1034. static STATUS hid176(){
  1035. PARSER SOMESPACE, somesequents;
  1036. return(p_andparse0n(TOPARSER SOMESPACE,0,TOPARSER somesequents,0));
  1037. }
  1038. static VOID hid177(){
  1039.  char *n;VV(3)=(GETNEWNAME(&n,plainenv,NULL),P_AND(n,V(1),V(3))); 
  1040. }
  1041. static STATUS hid178(){
  1042. PARSER hid176;ACTION hid177;
  1043. return(p_attach0n(TOPARSER hid176,0,hid177,0));
  1044. }
  1045. static STATUS hid179(){
  1046. PARSER hid178, p_nothing0;
  1047. return(p_andparse0n(TOPARSER hid178,0,TOPARSER p_nothing0,0));
  1048. }
  1049. static STATUS hid180(){
  1050. PARSER hid175, hid179;
  1051. return(p_orparse0n(TOPARSER hid175,0,TOPARSER hid179,0));
  1052. }
  1053. STATUS moresequents(){
  1054. PARSER hid180;
  1055. return((TOPARSER hid180)());
  1056. }
  1057.  
  1058.         /* Don't overpull now because ... */
  1059.  
  1060. static STATUS hid181(){
  1061. PARSER postfix;
  1062. return(p_option0n(TOPARSER postfix,0));
  1063. }
  1064. static STATUS hid182(){
  1065. PARSER seqoperand, hid181;
  1066. return(p_andparse0n(TOPARSER seqoperand,0,TOPARSER hid181,0));
  1067. }
  1068. STATUS sequent(){
  1069. PARSER hid182;
  1070. return((TOPARSER hid182)());
  1071. }
  1072.  
  1073.         /* in each of these cases the postfix must behave as though the
  1074.         seqoperand were before it and overpull its arguments and write into
  1075.         the stack position to the left of itself */
  1076.  
  1077. static STATUS hid183(){
  1078. PARSER plusop, hideop;
  1079. return(p_orparse0n(TOPARSER plusop,0,TOPARSER hideop,0));
  1080. }
  1081. static STATUS hid184(){
  1082. PARSER starop, hid183;
  1083. return(p_orparse0n(TOPARSER starop,0,TOPARSER hid183,0));
  1084. }
  1085. STATUS postfix(){
  1086. PARSER hid184;
  1087. return((TOPARSER hid184)());
  1088. }
  1089.  
  1090. static STATUS hid185(){
  1091. PARSER WHITESPACE, CLOSEBRACE;
  1092. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER CLOSEBRACE,0));
  1093. }
  1094. static STATUS hid186(){
  1095. PARSER expression, hid185;
  1096. return(p_andparse0n(TOPARSER expression,0,TOPARSER hid185,0));
  1097. }
  1098. static STATUS hid187(){
  1099. PARSER WHITESPACE, hid186;
  1100. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid186,0));
  1101. }
  1102. static STATUS hid188(){
  1103. PARSER OPENBRACE, hid187;
  1104. return(p_andparse0n(TOPARSER OPENBRACE,0,TOPARSER hid187,0));
  1105. }
  1106. static VOID hid189(){
  1107.  VV(5) = V(3); 
  1108. }
  1109. static STATUS hid190(){
  1110. PARSER hid188;ACTION hid189;
  1111. return(p_attach0n(TOPARSER hid188,0,hid189,0));
  1112. }
  1113. static STATUS hid191(){
  1114. PARSER hid190, p_nothing0;
  1115. return(p_andparse0n(TOPARSER hid190,0,TOPARSER p_nothing0,0));
  1116. }
  1117. STATUS bracket(){
  1118. PARSER hid191;
  1119. return((TOPARSER hid191)());
  1120. }
  1121.  
  1122. static STATUS hid192(){
  1123. PARSER WHITESPACE, CLOSEBRACKET;
  1124. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER CLOSEBRACKET,0));
  1125. }
  1126. static STATUS hid193(){
  1127. PARSER expression, hid192;
  1128. return(p_andparse0n(TOPARSER expression,0,TOPARSER hid192,0));
  1129. }
  1130. static STATUS hid194(){
  1131. PARSER WHITESPACE, hid193;
  1132. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid193,0));
  1133. }
  1134. static STATUS hid195(){
  1135. PARSER OPENBRACKET, hid194;
  1136. return(p_andparse0n(TOPARSER OPENBRACKET,0,TOPARSER hid194,0));
  1137. }
  1138. static VOID hid196(){
  1139.  char *n;VV(5)=(GETNEWNAME(&n,plainenv,NULL),P_OPT(n,V(3))); 
  1140. }
  1141. static STATUS hid197(){
  1142. PARSER hid195;ACTION hid196;
  1143. return(p_attach0n(TOPARSER hid195,0,hid196,0));
  1144. }
  1145. static STATUS hid198(){
  1146. PARSER hid197, p_nothing0;
  1147. return(p_andparse0n(TOPARSER hid197,0,TOPARSER p_nothing0,0));
  1148. }
  1149. STATUS option(){
  1150. PARSER hid198;
  1151. return((TOPARSER hid198)());
  1152. }
  1153.  
  1154. static VOID hid199(){
  1155.  VV(0)= "p_nothing0"; 
  1156. }
  1157. static STATUS hid200(){
  1158. PARSER p_nothing0;ACTION hid199;
  1159. return(p_attach0n(TOPARSER p_nothing0,0,hid199,0));
  1160. }
  1161. static STATUS hid201(){
  1162. PARSER hid200, p_nothing0;
  1163. return(p_andparse0n(TOPARSER hid200,0,TOPARSER p_nothing0,0));
  1164. }
  1165. STATUS empty(){
  1166. PARSER hid201;
  1167. return((TOPARSER hid201)());
  1168. }
  1169.  
  1170. static STATUS hid202(){
  1171. PARSER AT, expr;
  1172. return(p_andparse0n(TOPARSER AT,0,TOPARSER expr,0));
  1173. }
  1174. static VOID hid203(){
  1175. char *n; VV(2)=(getname(&V(2)),           GETNEWNAME(&n,plainenv,NULL),P_ATA(n,V(2))); 
  1176. }
  1177. static STATUS hid204(){
  1178. PARSER hid202;ACTION hid203;
  1179. return(p_attach0n(TOPARSER hid202,0,hid203,0));
  1180. }
  1181. static STATUS hid205(){
  1182. PARSER hid204, p_nothing0;
  1183. return(p_andparse0n(TOPARSER hid204,0,TOPARSER p_nothing0,0));
  1184. }
  1185. STATUS result(){
  1186. PARSER hid205;
  1187. return((TOPARSER hid205)());
  1188. }
  1189.  
  1190.                 /* here is one overpull */
  1191.  
  1192. int starflag=0;
  1193. char *starqual;
  1194.  
  1195. static VOID hid206(){
  1196. starflag=1;VV(2)=(getname(&V(2)),V(2));
  1197. }
  1198. static STATUS hid207(){
  1199. PARSER expr;ACTION hid206;
  1200. return(p_attach0n(TOPARSER expr,0,hid206,0));
  1201. }
  1202. static STATUS hid208(){
  1203. PARSER hid207, p_nothing0;
  1204. return(p_andparse0n(TOPARSER hid207,0,TOPARSER p_nothing0,0));
  1205. }
  1206. static STATUS hid209(){
  1207. PARSER hid208;
  1208. return(p_option0n(TOPARSER hid208,0));
  1209. }
  1210. static STATUS hid210(){
  1211. PARSER STAR, hid209;
  1212. return(p_andparse0n(TOPARSER STAR,0,TOPARSER hid209,0));
  1213. }
  1214. static VOID hid211(){
  1215.  char *n;if(starflag){                  VV(2)=(GETNEWNAME(&n,plainenv,NULL),P_ITR(n,V(1),V(3)));                   }  else {                  VV(2)=(GETNEWNAME(&n,plainenv,NULL),P_INF(n,V(1)));                  }  starflag=0; 
  1216. }
  1217. static STATUS hid212(){
  1218. PARSER hid210;ACTION hid211;
  1219. return(p_attach0n(TOPARSER hid210,0,hid211,0));
  1220. }
  1221. static STATUS hid213(){
  1222. PARSER hid212, p_nothing0;
  1223. return(p_andparse0n(TOPARSER hid212,0,TOPARSER p_nothing0,0));
  1224. }
  1225. STATUS starop(){
  1226. PARSER hid213;
  1227. return((TOPARSER hid213)());
  1228. }
  1229.  
  1230. static VOID hid214(){
  1231.  VV(1)="p_anything0"; 
  1232. }
  1233. static STATUS hid215(){
  1234. PARSER QUESTION;ACTION hid214;
  1235. return(p_attach0n(TOPARSER QUESTION,0,hid214,0));
  1236. }
  1237. static STATUS hid216(){
  1238. PARSER hid215, p_nothing0;
  1239. return(p_andparse0n(TOPARSER hid215,0,TOPARSER p_nothing0,0));
  1240. }
  1241. STATUS anymatch(){
  1242. PARSER hid216;
  1243. return((TOPARSER hid216)());
  1244. }
  1245.  
  1246. /* recall that exprnames get saved in the cbuff */
  1247.  
  1248. static STATUS hid217(){
  1249. PARSER plingmatch, exprname;
  1250. return(p_orparse0n(TOPARSER plingmatch,0,TOPARSER exprname,0));
  1251. }
  1252. static STATUS hid218(){
  1253. PARSER plingexpr, hid217;
  1254. return(p_orparse0n(TOPARSER plingexpr,0,TOPARSER hid217,0));
  1255. }
  1256. static STATUS hid219(){
  1257. PARSER finishmatch, hid218;
  1258. return(p_orparse0n(TOPARSER finishmatch,0,TOPARSER hid218,0));
  1259. }
  1260. static STATUS hid220(){
  1261. PARSER dollarplingmatch, hid219;
  1262. return(p_orparse0n(TOPARSER dollarplingmatch,0,TOPARSER hid219,0));
  1263. }
  1264. static STATUS hid221(){
  1265. PARSER eofmatch, hid220;
  1266. return(p_orparse0n(TOPARSER eofmatch,0,TOPARSER hid220,0));
  1267. }
  1268. static STATUS hid222(){
  1269. PARSER beginmatch, hid221;
  1270. return(p_orparse0n(TOPARSER beginmatch,0,TOPARSER hid221,0));
  1271. }
  1272. static STATUS hid223(){
  1273. PARSER anymatch, hid222;
  1274. return(p_orparse0n(TOPARSER anymatch,0,TOPARSER hid222,0));
  1275. }
  1276. static STATUS hid224(){
  1277. PARSER result, hid223;
  1278. return(p_orparse0n(TOPARSER result,0,TOPARSER hid223,0));
  1279. }
  1280. static STATUS hid225(){
  1281. PARSER phantom, hid224;
  1282. return(p_orparse0n(TOPARSER phantom,0,TOPARSER hid224,0));
  1283. }
  1284. static STATUS hid226(){
  1285. PARSER test, hid225;
  1286. return(p_orparse0n(TOPARSER test,0,TOPARSER hid225,0));
  1287. }
  1288. static STATUS hid227(){
  1289. PARSER range, hid226;
  1290. return(p_orparse0n(TOPARSER range,0,TOPARSER hid226,0));
  1291. }
  1292. static STATUS hid228(){
  1293. PARSER antiliteral, hid227;
  1294. return(p_orparse0n(TOPARSER antiliteral,0,TOPARSER hid227,0));
  1295. }
  1296. static STATUS hid229(){
  1297. PARSER literal, hid228;
  1298. return(p_orparse0n(TOPARSER literal,0,TOPARSER hid228,0));
  1299. }
  1300. static STATUS hid230(){
  1301. PARSER option, hid229;
  1302. return(p_orparse0n(TOPARSER option,0,TOPARSER hid229,0));
  1303. }
  1304. static STATUS hid231(){
  1305. PARSER bracket, hid230;
  1306. return(p_orparse0n(TOPARSER bracket,0,TOPARSER hid230,0));
  1307. }
  1308. STATUS seqoperand(){
  1309. PARSER hid231;
  1310. return((TOPARSER hid231)());
  1311. }
  1312.  
  1313. static STATUS hid232(){
  1314. PARSER PLING, bracket;
  1315. return(p_andparse0n(TOPARSER PLING,0,TOPARSER bracket,0));
  1316. }
  1317. static VOID hid233(){
  1318.  char *n;   VV(2)=(GETNEWNAME(&n,plainenv,NULL),P_ERR(n,V(2))); 
  1319. }
  1320. static STATUS hid234(){
  1321. PARSER hid232;ACTION hid233;
  1322. return(p_attach0n(TOPARSER hid232,0,hid233,0));
  1323. }
  1324. static STATUS hid235(){
  1325. PARSER hid234, p_nothing0;
  1326. return(p_andparse0n(TOPARSER hid234,0,TOPARSER p_nothing0,0));
  1327. }
  1328. STATUS plingexpr(){
  1329. PARSER hid235;
  1330. return((TOPARSER hid235)());
  1331. }
  1332.  
  1333. static STATUS hid236(){
  1334. PARSER WHITESPACE, OPENBRACKET;
  1335. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER OPENBRACKET,0));
  1336. }
  1337. static STATUS hid237(){
  1338. PARSER expression, hid236;
  1339. return(p_andparse0n(TOPARSER expression,0,TOPARSER hid236,0));
  1340. }
  1341. static STATUS hid238(){
  1342. PARSER WHITESPACE, hid237;
  1343. return(p_andparse0n(TOPARSER WHITESPACE,0,TOPARSER hid237,0));
  1344. }
  1345. static STATUS hid239(){
  1346. PARSER CLOSEBRACKET, hid238;
  1347. return(p_andparse0n(TOPARSER CLOSEBRACKET,0,TOPARSER hid238,0));
  1348. }
  1349. static VOID hid240(){
  1350. char *n;VV(5)=(GETNEWNAME(&n,plainenv,NULL),P_PHA(n,V(3))); 
  1351. }
  1352. static STATUS hid241(){
  1353. PARSER hid239;ACTION hid240;
  1354. return(p_attach0n(TOPARSER hid239,0,hid240,0));
  1355. }
  1356. static STATUS hid242(){
  1357. PARSER hid241, p_nothing0;
  1358. return(p_andparse0n(TOPARSER hid241,0,TOPARSER p_nothing0,0));
  1359. }
  1360. STATUS phantom(){
  1361. PARSER hid242;
  1362. return((TOPARSER hid242)());
  1363. }
  1364.  
  1365. /* a literal is anything inside angle brackets.
  1366.  * an antiliteral is anything inside anti angle brackets.
  1367.  * anglebrackets inside may be escaped to protect them
  1368.  */
  1369.  
  1370. static VOID hid243(){
  1371.  VV(1) = putchar(T(1)); 
  1372. }
  1373. static STATUS hid244(){
  1374. PARSER NOTARIGHTANGLEBRACKET;ACTION hid243;
  1375. return(p_attach0n(TOPARSER NOTARIGHTANGLEBRACKET,0,hid243,0));
  1376. }
  1377. static STATUS hid245(){
  1378. PARSER hid244, p_nothing0;
  1379. return(p_andparse0n(TOPARSER hid244,0,TOPARSER p_nothing0,0));
  1380. }
  1381. static STATUS hid246(){
  1382. PARSER COMMENT, hid245;
  1383. return(p_orparse0n(TOPARSER COMMENT,0,TOPARSER hid245,0));
  1384. }
  1385. static STATUS hid247(){
  1386. PARSER CHARCONST, hid246;
  1387. return(p_orparse0n(TOPARSER CHARCONST,0,TOPARSER hid246,0));
  1388. }
  1389. static STATUS hid248(){
  1390. PARSER STRING, hid247;
  1391. return(p_orparse0n(TOPARSER STRING,0,TOPARSER hid247,0));
  1392. }
  1393. STATUS lstuff(){
  1394. PARSER hid248;
  1395. return((TOPARSER hid248)());
  1396. }
  1397.  
  1398. static VOID hid249(){
  1399.  VV(1) = putchar(T(1)); 
  1400. }
  1401. static STATUS hid250(){
  1402. PARSER NOTALEFTANGLEBRACKET;ACTION hid249;
  1403. return(p_attach0n(TOPARSER NOTALEFTANGLEBRACKET,0,hid249,0));
  1404. }
  1405. static STATUS hid251(){
  1406. PARSER hid250, p_nothing0;
  1407. return(p_andparse0n(TOPARSER hid250,0,TOPARSER p_nothing0,0));
  1408. }
  1409. static STATUS hid252(){
  1410. PARSER COMMENT, hid251;
  1411. return(p_orparse0n(TOPARSER COMMENT,0,TOPARSER hid251,0));
  1412. }
  1413. static STATUS hid253(){
  1414. PARSER CHARCONST, hid252;
  1415. return(p_orparse0n(TOPARSER CHARCONST,0,TOPARSER hid252,0));
  1416. }
  1417. static STATUS hid254(){
  1418. PARSER STRING, hid253;
  1419. return(p_orparse0n(TOPARSER STRING,0,TOPARSER hid253,0));
  1420. }
  1421. STATUS alstuff(){
  1422. PARSER hid254;
  1423. return((TOPARSER hid254)());
  1424. }
  1425.  
  1426. static VOID hid255(){
  1427.  VV(2) = V(1); 
  1428. }
  1429. static STATUS hid256(){
  1430. PARSER lstuff;ACTION hid255;
  1431. return(p_attach0n(TOPARSER lstuff,0,hid255,0));
  1432. }
  1433. static STATUS hid257(){
  1434. PARSER hid256, p_nothing0;
  1435. return(p_andparse0n(TOPARSER hid256,0,TOPARSER p_nothing0,0));
  1436. }
  1437. static STATUS hid258(){
  1438. PARSER hid257;
  1439. return(p_many0n(TOPARSER hid257,0));
  1440. }
  1441. static STATUS hid259(){
  1442. PARSER lstuff, hid258;
  1443. return(p_andparse0n(TOPARSER lstuff,0,TOPARSER hid258,0));
  1444. }
  1445. static VOID hid260(){
  1446.  VV(0)=""; 
  1447. }
  1448. static STATUS hid261(){
  1449. PARSER p_nothing0;ACTION hid260;
  1450. return(p_attach0n(TOPARSER p_nothing0,0,hid260,0));
  1451. }
  1452. static STATUS hid262(){
  1453. PARSER hid261, p_nothing0;
  1454. return(p_andparse0n(TOPARSER hid261,0,TOPARSER p_nothing0,0));
  1455. }
  1456. static STATUS hid263(){
  1457. PARSER hid259, hid262;
  1458. return(p_orparse0n(TOPARSER hid259,0,TOPARSER hid262,0));
  1459. }
  1460. STATUS lstuffs(){
  1461. PARSER hid263;
  1462. return((TOPARSER hid263)());
  1463. }
  1464.  
  1465. /* close the accumulator for lstuffs */
  1466.  
  1467. static VOID hid264(){
  1468. VV(1)=V(1);getname(&V(1));
  1469. }
  1470. static STATUS hid265(){
  1471. PARSER lstuffs;ACTION hid264;
  1472. return(p_attach0n(TOPARSER lstuffs,0,hid264,0));
  1473. }
  1474. static STATUS hid266(){
  1475. PARSER hid265, p_nothing0;
  1476. return(p_andparse0n(TOPARSER hid265,0,TOPARSER p_nothing0,0));
  1477. }
  1478. STATUS lits(){
  1479. PARSER hid266;
  1480. return((TOPARSER hid266)());
  1481. }
  1482.  
  1483. static VOID hid267(){
  1484.  VV(2) = V(1); 
  1485. }
  1486. static STATUS hid268(){
  1487. PARSER alstuff;ACTION hid267;
  1488. return(p_attach0n(TOPARSER alstuff,0,hid267,0));
  1489. }
  1490. static STATUS hid269(){
  1491. PARSER hid268, p_nothing0;
  1492. return(p_andparse0n(TOPARSER hid268,0,TOPARSER p_nothing0,0));
  1493. }
  1494. static STATUS hid270(){
  1495. PARSER hid269;
  1496. return(p_many0n(TOPARSER hid269,0));
  1497. }
  1498. static STATUS hid271(){
  1499. PARSER alstuff, hid270;
  1500. return(p_andparse0n(TOPARSER alstuff,0,TOPARSER hid270,0));
  1501. }
  1502. static VOID hid272(){
  1503.  VV(0)=""; 
  1504. }
  1505. static STATUS hid273(){
  1506. PARSER p_nothing0;ACTION hid272;
  1507. return(p_attach0n(TOPARSER p_nothing0,0,hid272,0));
  1508. }
  1509. static STATUS hid274(){
  1510. PARSER hid273, p_nothing0;
  1511. return(p_andparse0n(TOPARSER hid273,0,TOPARSER p_nothing0,0));
  1512. }
  1513. static STATUS hid275(){
  1514. PARSER hid271, hid274;
  1515. return(p_orparse0n(TOPARSER hid271,0,TOPARSER hid274,0));
  1516. }
  1517. STATUS alstuffs(){
  1518. PARSER hid275;
  1519. return((TOPARSER hid275)());
  1520. }
  1521.  
  1522. /* close the accumulator for alstuffs */
  1523.  
  1524. static VOID hid276(){
  1525. VV(1)=V(1);getname(&V(1));
  1526. }
  1527. static STATUS hid277(){
  1528. PARSER alstuffs;ACTION hid276;
  1529. return(p_attach0n(TOPARSER alstuffs,0,hid276,0));
  1530. }
  1531. static STATUS hid278(){
  1532. PARSER hid277, p_nothing0;
  1533. return(p_andparse0n(TOPARSER hid277,0,TOPARSER p_nothing0,0));
  1534. }
  1535. STATUS alits(){
  1536. PARSER hid278;
  1537. return((TOPARSER hid278)());
  1538. }
  1539.  
  1540. static STATUS hid279(){
  1541. PARSER lits, RIGHTANGLEBRACKET;
  1542. return(p_andparse0n(TOPARSER lits,0,TOPARSER RIGHTANGLEBRACKET,0));
  1543. }
  1544. static STATUS hid280(){
  1545. PARSER LEFTANGLEBRACKET, hid279;
  1546. return(p_andparse0n(TOPARSER LEFTANGLEBRACKET,0,TOPARSER hid279,0));
  1547. }
  1548. static VOID hid281(){
  1549.  VV(3) = V(2); 
  1550. }
  1551. static STATUS hid282(){
  1552. PARSER hid280;ACTION hid281;
  1553. return(p_attach0n(TOPARSER hid280,0,hid281,0));
  1554. }
  1555. static STATUS hid283(){
  1556. PARSER hid282, p_nothing0;
  1557. return(p_andparse0n(TOPARSER hid282,0,TOPARSER p_nothing0,0));
  1558. }
  1559. STATUS LITERAL(){
  1560. PARSER hid283;
  1561. return((TOPARSER hid283)());
  1562. }
  1563.  
  1564. static STATUS hid284(){
  1565. PARSER alits, LEFTANGLEBRACKET;
  1566. return(p_andparse0n(TOPARSER alits,0,TOPARSER LEFTANGLEBRACKET,0));
  1567. }
  1568. static STATUS hid285(){
  1569. PARSER RIGHTANGLEBRACKET, hid284;
  1570. return(p_andparse0n(TOPARSER RIGHTANGLEBRACKET,0,TOPARSER hid284,0));
  1571. }
  1572. static VOID hid286(){
  1573.  VV(3) = V(2) ; 
  1574. }
  1575. static STATUS hid287(){
  1576. PARSER hid285;ACTION hid286;
  1577. return(p_attach0n(TOPARSER hid285,0,hid286,0));
  1578. }
  1579. static STATUS hid288(){
  1580. PARSER hid287, p_nothing0;
  1581. return(p_andparse0n(TOPARSER hid287,0,TOPARSER p_nothing0,0));
  1582. }
  1583. STATUS ANTILITERAL(){
  1584. PARSER hid288;
  1585. return((TOPARSER hid288)());
  1586. }
  1587.  
  1588.  
  1589. static VOID hid289(){
  1590. char *n;VV(1)=(GETNEWNAME(&n,plainenv,NULL),P_LIT(n,V(1))); 
  1591. }
  1592. static STATUS hid290(){
  1593. PARSER LITERAL;ACTION hid289;
  1594. return(p_attach0n(TOPARSER LITERAL,0,hid289,0));
  1595. }
  1596. static STATUS hid291(){
  1597. PARSER hid290, p_nothing0;
  1598. return(p_andparse0n(TOPARSER hid290,0,TOPARSER p_nothing0,0));
  1599. }
  1600. STATUS literal(){
  1601. PARSER hid291;
  1602. return((TOPARSER hid291)());
  1603. }
  1604.  
  1605. static VOID hid292(){
  1606. char *n;VV(1)=(GETNEWNAME(&n,plainenv,NULL),P_ALI(n,V(1))); 
  1607. }
  1608. static STATUS hid293(){
  1609. PARSER ANTILITERAL;ACTION hid292;
  1610. return(p_attach0n(TOPARSER ANTILITERAL,0,hid292,0));
  1611. }
  1612. static STATUS hid294(){
  1613. PARSER hid293, p_nothing0;
  1614. return(p_andparse0n(TOPARSER hid293,0,TOPARSER p_nothing0,0));
  1615. }
  1616. STATUS antiliteral(){
  1617. PARSER hid294;
  1618. return((TOPARSER hid294)());
  1619. }
  1620.  
  1621. static STATUS hid295(){
  1622. PARSER expr, CLOSEPAREN;
  1623. return(p_andparse0n(TOPARSER expr,0,TOPARSER CLOSEPAREN,0));
  1624. }
  1625. static STATUS hid296(){
  1626. PARSER OPENPAREN, hid295;
  1627. return(p_andparse0n(TOPARSER OPENPAREN,0,TOPARSER hid295,0));
  1628. }
  1629. static VOID hid297(){
  1630. char *n;VV(3)=(getname(&V(2)),GETNEWNAME(&n,plainenv,NULL),P_RAN(n,V(2)));
  1631. }
  1632. static STATUS hid298(){
  1633. PARSER hid296;ACTION hid297;
  1634. return(p_attach0n(TOPARSER hid296,0,hid297,0));
  1635. }
  1636. static STATUS hid299(){
  1637. PARSER hid298, p_nothing0;
  1638. return(p_andparse0n(TOPARSER hid298,0,TOPARSER p_nothing0,0));
  1639. }
  1640. STATUS range(){
  1641. PARSER hid299;
  1642. return((TOPARSER hid299)());
  1643. }
  1644.  
  1645. static STATUS hid300(){
  1646. PARSER expr, OPENPAREN;
  1647. return(p_andparse0n(TOPARSER expr,0,TOPARSER OPENPAREN,0));
  1648. }
  1649. static STATUS hid301(){
  1650. PARSER CLOSEPAREN, hid300;
  1651. return(p_andparse0n(TOPARSER CLOSEPAREN,0,TOPARSER hid300,0));
  1652. }
  1653. static VOID hid302(){
  1654. char *n;VV(3)=(getname(&V(2)),GETNEWNAME(&n,plainenv,NULL),P_TST(n,V(2)));
  1655. }
  1656. static STATUS hid303(){
  1657. PARSER hid301;ACTION hid302;
  1658. return(p_attach0n(TOPARSER hid301,0,hid302,0));
  1659. }
  1660. static STATUS hid304(){
  1661. PARSER hid303, p_nothing0;
  1662. return(p_andparse0n(TOPARSER hid303,0,TOPARSER p_nothing0,0));
  1663. }
  1664. STATUS test(){
  1665. PARSER hid304;
  1666. return((TOPARSER hid304)());
  1667. }
  1668.  
  1669. static VOID hid305(){
  1670.  VV(1)="p_first0"; 
  1671. }
  1672. static STATUS hid306(){
  1673. PARSER CARET;ACTION hid305;
  1674. return(p_attach0n(TOPARSER CARET,0,hid305,0));
  1675. }
  1676. static STATUS hid307(){
  1677. PARSER hid306, p_nothing0;
  1678. return(p_andparse0n(TOPARSER hid306,0,TOPARSER p_nothing0,0));
  1679. }
  1680. STATUS beginmatch(){
  1681. PARSER hid307;
  1682. return((TOPARSER hid307)());
  1683. }
  1684.  
  1685. static VOID hid308(){
  1686.  VV(1)="p_last0"; 
  1687. }
  1688. static STATUS hid309(){
  1689. PARSER DOLLAR;ACTION hid308;
  1690. return(p_attach0n(TOPARSER DOLLAR,0,hid308,0));
  1691. }
  1692. static STATUS hid310(){
  1693. PARSER hid309, p_nothing0;
  1694. return(p_andparse0n(TOPARSER hid309,0,TOPARSER p_nothing0,0));
  1695. }
  1696. STATUS finishmatch(){
  1697. PARSER hid310;
  1698. return((TOPARSER hid310)());
  1699. }
  1700.  
  1701. static VOID hid311(){
  1702.  VV(1)="p_uniq0"; 
  1703. }
  1704. static STATUS hid312(){
  1705. PARSER PLING;ACTION hid311;
  1706. return(p_attach0n(TOPARSER PLING,0,hid311,0));
  1707. }
  1708. static STATUS hid313(){
  1709. PARSER hid312, p_nothing0;
  1710. return(p_andparse0n(TOPARSER hid312,0,TOPARSER p_nothing0,0));
  1711. }
  1712. STATUS plingmatch(){
  1713. PARSER hid313;
  1714. return((TOPARSER hid313)());
  1715. }
  1716.  
  1717. static STATUS hid314(){
  1718. PARSER DOLLAR, PLING;
  1719. return(p_andparse0n(TOPARSER DOLLAR,0,TOPARSER PLING,0));
  1720. ))static VOID hid315(){
  1721.  VV(2)="p_lastuniq0"; 
  1722. }
  1723. static STATUS hid316(){
  1724. PARSER hid314;ACTION hid315;
  1725. return(p_attach0n(TOPARSER hid314,0,hid315,0));
  1726. }
  1727. static STATUS hid317(){
  1728. PARSER hid316, p_nothing0;
  1729. return(p_andparse0n(TOPARSER hid316,0,TOPARSER p_nothing0,0));
  1730. }
  1731. STATUS dollarplingmatch(){
  1732. PARSER hid317;
  1733. return((TOPARSER hid317)());
  1734. }
  1735.  
  1736. static STATUS hid318(){
  1737. PARSER DOLLAR, DOLLAR;
  1738. return(p_andparse0n(TOPARSER DOLLAR,0,TOPARSER DOLLAR,0));
  1739. }
  1740. static VOID hid319(){
  1741.  VV(2)="p_eof0"; 
  1742. }
  1743. static STATUS hid320(){
  1744. PARSER hid318;ACTION hid319;
  1745. return(p_attach0n(TOPARSER hid318,0,hid319,0));
  1746. }
  1747. static STATUS hid321(){
  1748. PARSER hid320, p_nothing0;
  1749. return(p_andparse0n(TOPARSER hid320,0,TOPARSER p_nothing0,0));
  1750. }
  1751. STATUS eofmatch(){
  1752. PARSER hid321;
  1753. return((TOPARSER hid321)());
  1754. }
  1755.  
  1756.                 /* another overpull */
  1757.  
  1758. static VOID hid322(){
  1759.  char *n;VV(2)=(GETNEWNAME(&n,plainenv,NULL),P_SOM(n,V(1))); 
  1760. }
  1761. static STATUS hid323(){
  1762. PARSER PLUS;ACTION hid322;
  1763. return(p_attach0n(TOPARSER PLUS,0,hid322,0));
  1764. }
  1765. static STATUS hid324(){
  1766. PARSER hid323, p_nothing0;
  1767. return(p_andparse0n(TOPARSER hid323,0,TOPARSER p_nothing0,0));
  1768. }
  1769. STATUS plusop(){
  1770. PARSER hid324;
  1771. return((TOPARSER hid324)());
  1772. }
  1773.  
  1774. static STATUS hid325(){
  1775. PARSER expr, CLOSEPAREN;
  1776. return(p_andparse0n(TOPARSER expr,0,TOPARSER CLOSEPAREN,0));
  1777. }
  1778. static STATUS hid326(){
  1779. PARSER OPENPAREN, hid325;
  1780. return(p_andparse0n(TOPARSER OPENPAREN,0,TOPARSER hid325,0));
  1781. }
  1782. static STATUS hid327(){
  1783. PARSER SLASH, hid326;
  1784. return(p_andparse0n(TOPARSER SLASH,0,TOPARSER hid326,0));
  1785. }
  1786. static VOID hid328(){
  1787. char *n;   VV(5)=(getname(&V(4)),GETNEWNAME(&n,plainenv,NULL),P_HID(n,V(1),V(4)));
  1788. }
  1789. static STATUS hid329(){
  1790. PARSER hid327;ACTION hid328;
  1791. return(p_attach0n(TOPARSER hid327,0,hid328,0));
  1792. }
  1793. static STATUS hid330(){
  1794. PARSER hid329, p_nothing0;
  1795. return(p_andparse0n(TOPARSER hid329,0,TOPARSER p_nothing0,0));
  1796. }
  1797. STATUS hideop(){
  1798. PARSER hid330;
  1799. return((TOPARSER hid330)());
  1800. }
  1801.  
  1802.  
  1803.                 /* ------- finis -------- */
  1804.  
  1805. MAIN(line)
  1806.  
  1807.  
  1808.